package com.learning.platform.service;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.learning.platform.entity.UserLearningContext;
import com.learning.platform.enums.QueryIntent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

/**
 * 提示词增强服务
 * 根据用户意图和上下文增强AI提示词，使AI回答更专业和个性化
 */
@Service
public class PromptEnhancementService {
    
    @Autowired
    private UserContextService userContextService;
    
    // 编程专家系统提示模板
    private static final String PROGRAMMING_EXPERT_PROMPT = """
        你是一位资深的编程导师和技术专家，具有以下特质：
        
        🧠 **专业知识**：
        - 精通多种编程语言（Java、Python、JavaScript、C++等）
        - 深入理解算法、数据结构、设计模式
        - 熟悉各种开发框架和工具
        - 了解软件工程最佳实践
        
        👨‍🏫 **教学风格**：
        - 根据学习者水平调整解释深度
        - 总是提供清晰的概念解释和实际代码示例
        - 指出常见错误和最佳实践
        - 鼓励动手实践和深入思考
        
        🎯 **回答原则**：
        1. 先理解问题本质，再给出解决方案
        2. 提供可运行的代码示例（如果适用）
        3. 解释代码的工作原理和设计思路
        4. 指出潜在的问题和改进建议
        5. 推荐相关的学习资源或练习
        
        """;
    
    // 代码调试专家提示模板
    private static final String DEBUG_EXPERT_PROMPT = """
        你是一位经验丰富的代码调试专家，擅长：
        
        🔍 **错误诊断**：
        - 快速定位问题根源
        - 分析错误信息和堆栈跟踪
        - 识别常见的编程陷阱
        
        🛠️ **解决方案**：
        - 提供具体的修复步骤
        - 解释为什么会出现这个问题
        - 给出预防类似问题的建议
        
        请按以下格式回答调试问题：
        1. **问题分析**：解释错误的原因
        2. **解决方案**：提供修复代码
        3. **预防措施**：如何避免类似问题
        4. **相关知识点**：涉及的编程概念
        
        """;
    
    // 代码审查专家提示模板
    private static final String REVIEW_EXPERT_PROMPT = """
        你是一位代码审查专家，关注：
        
        📝 **代码质量**：
        - 代码可读性和维护性
        - 命名规范和代码风格
        - 逻辑清晰度和结构合理性
        
        ⚡ **性能优化**：
        - 算法效率分析
        - 内存使用优化
        - 潜在的性能瓶颈
        
        🔒 **安全性**：
        - 常见安全漏洞识别
        - 输入验证和数据处理
        - 最佳安全实践
        
        请按以下维度审查代码：
        1. **功能正确性**：代码是否实现预期功能
        2. **代码质量**：可读性、维护性评估
        3. **性能分析**：效率和优化建议
        4. **安全考虑**：潜在安全问题
        5. **改进建议**：具体的优化方案
        
        """;
    
    /**
     * 增强用户查询提示词
     */
    public String enhancePrompt(String userQuery, Long userId) {
        // 获取用户上下文
        UserLearningContext context = userContextService.getOrCreateContext(userId);
        
        // 识别查询意图
        IntentRecognitionService.IntentAnalysisResult analysis = 
            getIntentAnalysis(userQuery);
        
        // 根据意图选择专业提示模板
        String expertPrompt = selectExpertPrompt(analysis.getIntent());
        
        // 构建个性化上下文
        String personalizedContext = buildPersonalizedContext(context, analysis);
        
        // 组合最终提示词
        return buildFinalPrompt(expertPrompt, personalizedContext, userQuery, analysis);
    }
    
    /**
     * 获取意图分析结果（模拟实现）
     */
    private IntentRecognitionService.IntentAnalysisResult getIntentAnalysis(String query) {
        // 这里应该调用IntentRecognitionService，为了简化直接返回一个示例
        return IntentRecognitionService.IntentAnalysisResult.builder()
            .intent(QueryIntent.PROGRAMMING)
            .confidence(0.8)
            .hasCodePattern(query.contains("```") || query.contains("`"))
            .complexity("中等")
            .build();
    }
    
    /**
     * 选择专家提示模板
     */
    private String selectExpertPrompt(QueryIntent intent) {
        return switch (intent) {
            case CODE_DEBUG -> DEBUG_EXPERT_PROMPT;
            case CODE_REVIEW -> REVIEW_EXPERT_PROMPT;
            case PROGRAMMING, CONCEPT_EXPLANATION, PROJECT_HELP -> PROGRAMMING_EXPERT_PROMPT;
            default -> PROGRAMMING_EXPERT_PROMPT; // 默认使用编程专家提示
        };
    }
    
    /**
     * 构建个性化上下文
     */
    private String buildPersonalizedContext(UserLearningContext context, 
                                          IntentRecognitionService.IntentAnalysisResult analysis) {
        StringBuilder contextBuilder = new StringBuilder();
        
        contextBuilder.append("📊 **学习者档案**：\n");
        
        // 技能水平
        contextBuilder.append("- 当前水平: ").append(getSkillLevelDescription(context.getSkillLevel())).append("\n");
        
        // 当前学习语言
        if (context.getCurrentLanguage() != null) {
            contextBuilder.append("- 主要语言: ").append(context.getCurrentLanguage()).append("\n");
        }
        
        // 学习目标
        if (context.getLearningGoals() != null && !context.getLearningGoals().trim().isEmpty()) {
            contextBuilder.append("- 学习目标: ").append(context.getLearningGoals()).append("\n");
        }
        
        // 最近话题
        List<String> recentTopics = toList(context.getRecentTopics());
        if (!recentTopics.isEmpty()) {
            List<String> top = recentTopics.subList(0, Math.min(3, recentTopics.size()));
            contextBuilder.append("- 最近关注: ").append(String.join("、", top)).append("\n");
        }
        
        // 薄弱环节
        List<String> weakAreas = toList(context.getWeakAreas());
        if (!weakAreas.isEmpty()) {
            contextBuilder.append("- 需要加强: ").append(String.join("、", weakAreas)).append("\n");
        }
        
        // 优势领域
        List<String> strongAreas = toList(context.getStrongAreas());
        if (!strongAreas.isEmpty()) {
            contextBuilder.append("- 擅长领域: ").append(String.join("、", strongAreas)).append("\n");
        }
        
        contextBuilder.append("\n");
        
        // 学习偏好
        contextBuilder.append("🎯 **个性化要求**：\n");
        Map<String, Object> preferences = parsePreferences(context.getLearningPreferences());
        if (preferences != null) {
            String explanationStyle = (String) preferences.getOrDefault("explanationStyle", "详细");
            Boolean codeExamples = (Boolean) preferences.getOrDefault("codeExamples", true);
            
            contextBuilder.append("- 解释风格: ").append(explanationStyle).append("\n");
            if (codeExamples) {
                contextBuilder.append("- 需要代码示例和实际案例\n");
            }
            contextBuilder.append("- 根据学习者水平调整解释深度\n");
        }
        
        contextBuilder.append("\n");
        
        return contextBuilder.toString();
    }
    
    /**
     * 获取技能水平描述
     */
    private String getSkillLevelDescription(String skillLevel) {
        return switch (skillLevel) {
            case "BEGINNER" -> "初学者（需要基础概念解释和简单示例）";
            case "INTERMEDIATE" -> "中级（可以理解复杂概念，需要深入解释）";
            case "ADVANCED" -> "高级（关注最佳实践和高级技巧）";
            case "EXPERT" -> "专家级（可以讨论深层原理和架构设计）";
            default -> "学习者";
        };
    }
    
    /**
     * 构建最终提示词
     */
    private String buildFinalPrompt(String expertPrompt, String personalizedContext, 
                                   String userQuery, IntentRecognitionService.IntentAnalysisResult analysis) {
        StringBuilder finalPrompt = new StringBuilder();
        
        // 专家系统提示
        finalPrompt.append(expertPrompt).append("\n");
        
        // 个性化上下文
        finalPrompt.append(personalizedContext);
        
        // 查询分析信息
        if (analysis.isHasCodePattern()) {
            finalPrompt.append("💡 **注意**: 用户的问题包含代码，请特别关注代码分析和具体的技术实现。\n\n");
        }
        
        // 用户问题
        finalPrompt.append("❓ **用户问题**：\n").append(userQuery).append("\n\n");
        
        // 回答指导
        finalPrompt.append("请根据以上信息，提供专业、详细且适合学习者水平的回答。");
        
        return finalPrompt.toString();
    }

    private List<String> toList(Object raw) {
        if (raw == null) return Collections.emptyList();
        if (raw instanceof List<?>) {
            List<?> l = (List<?>) raw;
            List<String> out = new ArrayList<>();
            for (Object o : l) if (o != null) out.add(String.valueOf(o));
            return out;
        }
        String s = String.valueOf(raw);
        if (s.trim().isEmpty()) return Collections.emptyList();
        try {
            ObjectMapper mapper = new ObjectMapper();
            List<String> list = mapper.readValue(s, new TypeReference<List<String>>(){});
            return list != null ? list : Collections.emptyList();
        } catch (Exception ignore) {}
        return Arrays.stream(s.split("[,;\n]"))
                .map(String::trim)
                .filter(x -> !x.isEmpty())
                .toList();
    }

    private Map<String, Object> parsePreferences(Object raw) {
        if (raw == null) return Collections.emptyMap();
        if (raw instanceof Map<?, ?> m) {
            Map<String, Object> out = new HashMap<>();
            m.forEach((k,v) -> out.put(String.valueOf(k), v));
            return out;
        }
        String s = String.valueOf(raw);
        if (s.trim().isEmpty()) return Collections.emptyMap();
        try {
            ObjectMapper mapper = new ObjectMapper();
            Map<String, Object> map = mapper.readValue(s, new TypeReference<Map<String, Object>>(){});
            return map != null ? map : Collections.emptyMap();
        } catch (Exception e) {
            return Collections.emptyMap();
        }
    }
    
    /**
     * 为特定编程语言增强提示词
     */
    public String enhanceForLanguage(String basePrompt, String language) {
        if (language == null || language.trim().isEmpty()) {
            return basePrompt;
        }
        
        String languageContext = getLanguageSpecificContext(language);
        return basePrompt + "\n\n" + languageContext;
    }
    
    /**
     * 获取特定编程语言的上下文
     */
    private String getLanguageSpecificContext(String language) {
        Map<String, String> languageContexts = new HashMap<>();
        
        languageContexts.put("java", """
            🔶 **Java专项指导**：
            - 关注面向对象编程原则
            - 强调异常处理和资源管理
            - 提及Java生态系统（Spring、Maven等）
            - 注意内存管理和垃圾回收
            """);
        
        languageContexts.put("python", """
            🐍 **Python专项指导**：
            - 强调代码的简洁性和可读性
            - 关注Python特有的语法特性
            - 提及常用库和框架（Django、Flask、NumPy等）
            - 注意Python的动态特性和最佳实践
            """);
        
        languageContexts.put("javascript", """
            🌐 **JavaScript专项指导**：
            - 关注异步编程和事件驱动
            - 强调前端开发最佳实践
            - 提及现代JS特性（ES6+）
            - 注意浏览器兼容性和性能优化
            """);
        
        return languageContexts.getOrDefault(language.toLowerCase(), 
            "💻 **" + language + "专项指导**：请提供该语言相关的最佳实践和注意事项。");
    }
    
    /**
     * 为代码审查增强提示词
     */
    public String enhanceForCodeReview(String code, String language) {
        return String.format("""
            %s
            
            📋 **代码审查任务**：
            请对以下%s代码进行全面审查：
            
            ```%s
            %s
            ```
            
            请按照代码审查标准，从功能、质量、性能、安全等维度进行分析。
            """, REVIEW_EXPERT_PROMPT, language, language, code);
    }
    
    /**
     * 为错误调试增强提示词
     */
    public String enhanceForDebugging(String errorMessage, String code, String language) {
        return String.format("""
            %s
            
            🐛 **调试任务**：
            错误信息：%s
            
            相关代码（%s）：
            ```%s
            %s
            ```
            
            请帮助分析和解决这个问题。
            """, DEBUG_EXPERT_PROMPT, errorMessage, language, language, code);
    }
}
